home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ld / dist / patch2 / ld.c.rej < prev    next >
Encoding:
Text File  |  1990-10-26  |  48.5 KB  |  1,713 lines
  1. ***************
  2. *** 27,37 ****
  3.   #include <fcntl.h>
  4.   #endif
  5.   
  6.   #ifdef COFF_ENCAPSULATE
  7.   #include "a.out.encap.h"
  8.   #else
  9.   #include <a.out.h>
  10.   #endif
  11.   
  12.   #ifndef N_SET_MAGIC
  13.   #define N_SET_MAGIC(exec, val)  ((exec).a_magic = val)
  14. --- 27,170 ----
  15.   #include <fcntl.h>
  16.   #endif
  17.   
  18. + #define NO_C_PLUS_PLUS
  19. + 
  20. + #define TARGET_SUN2             2
  21. + #define TARGET_SUN3             3
  22. + #define TARGET_SUN4             4
  23. + #define TARGET_ALTOS            5
  24. + #define TARGET_I386             6   
  25. + #define TARGET_HPUX             7
  26. + #define TARGET_SONY_NEWS        8
  27. + #define TARGET_SEQUENT          9
  28. + #define TARGET_VAX              10
  29. + 
  30. + /*
  31. +  * If `TARGET_MACHINE' was not defined on the compiler command line,
  32. +  * then set it equal to the host machine.
  33. +  */
  34. + #ifndef TARGET_MACHINE
  35. + #if defined(sun) && defined(sparc)
  36. + #define TARGET_MACHINE  TARGET_SUN4
  37. + #endif
  38. + #if defined(sun) && (defined(m68020) || defined(mc68020))
  39. + #define TARGET_MACHINE  TARGET_SUN3
  40. + #endif
  41. + #if defined(sun) && (defined(m68010) || defined(mc68010))
  42. + #define TARGET_MACHINE  TARGET_SUN2
  43. + #endif
  44. + #if defined(ALTOS)
  45. + #define TARGET_MACHINE  TARGET_ALTOS
  46. + #endif
  47. + #if defined(hpux)
  48. + #define TARGET_MACHINE  TARGET_HPUX
  49. + #endif
  50. + #if defined(is386)
  51. + #define TARGET_MACHINE  TARGET_I386
  52. + #endif
  53. + #if defined(sony_news)
  54. + #define TARGET_MACHINE  TARGET_SONY_NEWS
  55. + #endif
  56. + #if defined(sequent)
  57. + #define TARGET_MACHINE  TARGET_SEQUENT
  58. + #endif
  59. + #if defined(is68k) && !defined(TARGET_MACHINE)
  60. + #define TARGET_MACHINE  TARGET_68K
  61. + #endif
  62. + #endif
  63. + 
  64. + #ifndef TARGET_MACHINE
  65. +     CANNOT COMPILE, NO TARGET MACHINE SPECIFIED
  66. + #endif
  67. + 
  68. + #ifndef BIG_ENDIAN
  69. + #define BIG_ENDIAN      4321
  70. + #endif
  71. + #ifndef LITTLE_ENDIAN
  72. + #define LITTLE_ENDIAN   1234
  73. + #endif
  74. + #ifndef PDP_ENDIAN
  75. + /* I think it is unlikely that anybody will try to cross compile
  76. +  * to or from a pdp, so only big-endian and little-endian are supported. */
  77. + #define PDP_ENDIAN   3412
  78. + #endif
  79. + 
  80. + #if TARGET_MACHINE==TARGET_SUN4         || \
  81. +     TARGET_MACHINE==TARGET_SUN3         || \
  82. +     TARGET_MACHINE==TARGET_SUN2         || \
  83. +     TARGET_MACHINE==TARGET_ALTOS        || \
  84. +     TARGET_MACHINE==TARGET_HPUX         || \
  85. +     TARGET_MACHINE==TARGET_SONY_NEWS    || \
  86. +     TARGET_MACHINE==TARGET_68K
  87. + #define TARGET_BYTE_ORDER       BIG_ENDIAN
  88. + #endif
  89. + 
  90. + #if TARGET_MACHINE==TARGET_VAX          || \
  91. +     TARGET_MACHINE==TARGET_I386         || \
  92. +     TARGET_MACHINE==TARGET_SEQUENT
  93. + #define TARGET_BYTE_ORDER       LITTLE_ENDIAN
  94. + #endif
  95. + 
  96. + #if TARGET_MACHINE==TARGET_SUN3
  97. + #define TARGET_PAGE_SIZE    0x2000
  98. + #endif
  99. + 
  100. + #if defined(sparc)      || \
  101. +     defined(m68000)     || \
  102. +     defined(mc68000)    || \
  103. +     defined(m68010)     || \
  104. +     defined(mc68010)    || \
  105. +     defined(m68020)     || \
  106. +     defined(mc68020)    || \
  107. +     defined(is68k)      || \
  108. +     defined(hpux)       || \
  109. +     defined(sony_news)
  110. + #define HOST_BYTE_ORDER     BIG_ENDIAN
  111. + #endif
  112. + 
  113. + #if defined(vax)        || \
  114. +     defined(is386)      || \
  115. +     defined(ds3100)     || \
  116. +     defined(sequent)
  117. + #define HOST_BYTE_ORDER     LITTLE_ENDIAN
  118. + #endif
  119. + 
  120. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  121. + static void fix_byte_order();
  122. + static void fix_exec_header_byte_order();
  123. + static void fix_symbol_byte_order();
  124. + static void target_to_host_reloc_byte_order();
  125. + static void host_to_target_reloc_byte_order();
  126. + static void fix_symbol_root_byte_order();
  127. + #endif
  128. + 
  129.   #ifdef COFF_ENCAPSULATE
  130.   #include "a.out.encap.h"
  131.   #else
  132. + #ifdef sprite
  133. + #if TARGET_MACHINE==TARGET_SUN4
  134. + #include <sun4.md/a.out.h>
  135. + #elif TARGET_MACHINE==TARGET_SUN3
  136. + #include <sun3.md/a.out.h>
  137. + #elif TARGET_MACHINE==TARGET_SEQUENT
  138. + #include <symm.md/a.out.h>
  139. + #else
  140. +     no a.out.h specified
  141. + #endif
  142. + #else
  143.   #include <a.out.h>
  144.   #endif
  145. + #endif
  146. + 
  147. + #ifdef sprite
  148. + #undef NEW_SEG_SIZE
  149. + #if TARGET_MACHINE==TARGET_SUN4
  150. + #define NEW_SEG_SIZE    0x40000
  151. + #endif
  152. + #if TARGET_MACHINE==TARGET_SUN3
  153. + #define NEW_SEG_SIZE    0x20000
  154. + #endif
  155. + #endif  /* sprite */
  156.   
  157.   #ifndef N_SET_MAGIC
  158.   #define N_SET_MAGIC(exec, val)  ((exec).a_magic = val)
  159. ***************
  160. *** 85,91 ****
  161.   
  162.   /* Define this to specify the default executable format.  */
  163.   
  164. ! #ifdef hpux
  165.   #define DEFAULT_MAGIC NMAGIC  /* hpux bugs screw ZMAGIC */
  166.   #endif
  167.   
  168. --- 218,224 ----
  169.   
  170.   /* Define this to specify the default executable format.  */
  171.   
  172. ! #if TARGET_MACHINE==TARGET_HPUX
  173.   #define DEFAULT_MAGIC NMAGIC  /* hpux bugs screw ZMAGIC */
  174.   #endif
  175.   
  176. ***************
  177. *** 96,125 ****
  178.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  179.   
  180.   #ifndef N_TXTADDR
  181. ! #if defined(vax) || defined(sony_news)
  182.   #define N_TXTADDR(X) 0
  183.   #endif
  184. ! #ifdef is68k
  185.   #define N_TXTADDR(x)  (sizeof (struct exec))
  186.   #endif
  187. ! #ifdef sequent
  188.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  189.   #endif
  190.   #endif
  191.   
  192.   #ifndef N_DATADDR
  193. ! #if defined(vax) || defined(sony_news)
  194.   #define N_DATADDR(x) \
  195.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  196.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  197.   #endif
  198. ! #ifdef is68k
  199.   #define SEGMENT_SIZE 0x20000
  200.   #define N_DATADDR(x) \
  201. !     (((x).a_magic==Omagic)? (N_TXTADDR(x)+(x).a_text) \
  202.        : (SEGMENT_SIZE + ((N_TXTADDR(x)+(x).a_text-1) & ~(SEGMENT_SIZE-1))))
  203.   #endif
  204. ! #ifdef sequent
  205.   #define N_DATADDR(x) \
  206.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  207.       : (page_size+(((x).a_text-1) & ~(page_size-1))))
  208. --- 229,258 ----
  209.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  210.   
  211.   #ifndef N_TXTADDR
  212. ! #if TARGET_MACHINE==TARGET_VAX || TARGET_MACHINE==TARGET_SONY_NEWS
  213.   #define N_TXTADDR(X) 0
  214.   #endif
  215. ! #if TARGET_MACHINE==TARGET_SUN3 || TARGET_MACHINE==TARGET_SUN2
  216.   #define N_TXTADDR(x)  (sizeof (struct exec))
  217.   #endif
  218. ! #if TARGET_MACHINE==TARGET_SEQUENT
  219.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  220.   #endif
  221.   #endif
  222.   
  223.   #ifndef N_DATADDR
  224. ! #if TARGET_MACHINE==TARGET_VAX || TARGET_MACHINE==TARGET_SONY_NEWS
  225.   #define N_DATADDR(x) \
  226.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  227.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  228.   #endif
  229. ! #if TARGET_MACHINE==TARGET_SUN3 || TARGET_MACHINE==TARGET_SUN2
  230.   #define SEGMENT_SIZE 0x20000
  231.   #define N_DATADDR(x) \
  232. !     (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  233.        : (SEGMENT_SIZE + ((N_TXTADDR(x)+(x).a_text-1) & ~(SEGMENT_SIZE-1))))
  234.   #endif
  235. ! #if TARGET_MACHINE==TARGET_SEQUENT
  236.   #define N_DATADDR(x) \
  237.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  238.       : (page_size+(((x).a_text-1) & ~(page_size-1))))
  239. ***************
  240. *** 127,168 ****
  241.   #endif
  242.   
  243.   /* Define how to initialize system-dependent header fields.  */
  244. ! #ifdef sun
  245. ! #ifdef sparc
  246.   #define INITIALIZE_HEADER \
  247.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  248.   #endif
  249. ! #if defined(mc68010) || defined(m68010)
  250.   #define INITIALIZE_HEADER outheader.a_machtype = M_68010
  251.   #endif
  252. ! #ifndef INITIALIZE_HEADER
  253.   #define INITIALIZE_HEADER outheader.a_machtype = M_68020
  254.   #endif
  255. ! #endif
  256. ! #ifdef ALTOS
  257.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  258.   #endif
  259. ! #ifdef is68k
  260. ! #ifdef M_68020
  261. ! /* ISI rel 4.0D doesn't use it, and rel 3.05 doesn't have an
  262. !    a_machtype field and so won't recognize the magic number.  To keep
  263. !    binary compatibility for now, just ignore it */
  264. ! #define INITIALIZE_HEADER outheader.a_machtype = 0;
  265. ! #endif
  266. ! #endif
  267. ! #ifdef hpux
  268.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, HP9000S200_ID)
  269.   #endif
  270. ! #if defined(i386) && !defined(sequent)
  271.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  272.   #endif
  273. ! 
  274. ! #ifdef is68k
  275.   /* This enables code to take care of an ugly hack in the ISI OS.
  276.      If a symbol beings with _$, then the object file is included only
  277.      if the rest of the symbol name has been referenced. */
  278.   #define DOLLAR_KLUDGE
  279.   #endif
  280.   
  281.   /*
  282.    * Alloca include.
  283. --- 260,312 ----
  284.   #endif
  285.   
  286.   /* Define how to initialize system-dependent header fields.  */
  287. ! #if TARGET_MACHINE==TARGET_SUN4
  288.   #define INITIALIZE_HEADER \
  289.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  290.   #endif
  291. ! #if TARGET_MACHINE==TARGET_SUN2
  292.   #define INITIALIZE_HEADER outheader.a_machtype = M_68010
  293.   #endif
  294. ! #if TARGET_MACHINE==TARGET_SUN3
  295.   #define INITIALIZE_HEADER outheader.a_machtype = M_68020
  296.   #endif
  297. ! #if TARGET_MACHINE==TARGET_ALTOS
  298.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  299.   #endif
  300. ! #if TARGET_MACHINE==TARGET_HPUX
  301.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, HP9000S200_ID)
  302.   #endif
  303. ! #if TARGET_MACHINE==TARGET_I386
  304.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  305.   #endif
  306. ! #if TARGET_MACHINE==TARGET_68K
  307. ! #define INITIALIZE_HEADER outheader.a_machtype = 0;  
  308.   /* This enables code to take care of an ugly hack in the ISI OS.
  309.      If a symbol beings with _$, then the object file is included only
  310.      if the rest of the symbol name has been referenced. */
  311.   #define DOLLAR_KLUDGE
  312.   #endif
  313. + #if TARGET==TARGET_SEQUENT
  314. + /* This is all stuff needed to make standalone binaries */
  315. + static struct gdtbl gdt_filler = {
  316. +     { 0x0000FFFF, 0x00CF9A00 },    /* code entry */
  317. +     { 0x0000FFFF, 0x00CF9200 },    /* data entry */
  318. +     { 0x00180017, 0x00000000 },    /* 6 byte descriptor */
  319. + };
  320. + 
  321. + static char instr[] = {
  322. +     0x67, 0x66, 0x0f, 0x01, 0x15, 0x30, 0x00, 0x00, 0x00,
  323. +     0x0f, 0x20, 0xc3,
  324. +     0x80, 0xcb, 0x01,
  325. +     0x0f, 0x22, 0xc3,
  326. +     0xea, 0x5b, 0x00, 0x08, 0x00,
  327. +     0xbb, 0x10, 0x00, 0x00, 0x00,
  328. +     0x8e, 0xdb,
  329. +     0x8e, 0xd3,
  330. +     0x8e, 0xc3,
  331. +     0xff, 0x25, 0x6c, 0x00, 0x00, 0x00,
  332. +     0x00, 0x00, 0x00, 0x00, };
  333. + #endif   
  334.   
  335.   /*
  336.    * Alloca include.
  337. ***************
  338. *** 319,330 ****
  339.   #define RELOC_MEMORY_SUB_P(r)        0
  340.   #define RELOC_MEMORY_ADD_P(r)           0
  341.   #define RELOC_ADD_EXTRA(r)              ((r)->r_addend)       
  342. ! #define RELOC_PCREL_P(r)             \
  343. !         ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22)
  344. ! #define RELOC_VALUE_RIGHTSHIFT(r)       (reloc_target_rightshift[(r)->r_type])
  345. ! #define RELOC_TARGET_SIZE(r)            (reloc_target_size[(r)->r_type])
  346.   #define RELOC_TARGET_BITPOS(r)          0
  347. ! #define RELOC_TARGET_BITSIZE(r)         (reloc_target_bitsize[(r)->r_type])
  348.   
  349.   /* Note that these are very dependent on the order of the enums in
  350.      enum reloc_type (in a.out.h); if they change the following must be
  351. --- 463,477 ----
  352.   #define RELOC_MEMORY_SUB_P(r)        0
  353.   #define RELOC_MEMORY_ADD_P(r)           0
  354.   #define RELOC_ADD_EXTRA(r)              ((r)->r_addend)       
  355. ! #define RELOC_PCREL_P(r)                \
  356. !     ((int) (r)->r_type >= (int) RELOC_DISP8 && \
  357. !      (int) (r)->r_type <= (int) RELOC_WDISP22)
  358. ! #define RELOC_VALUE_RIGHTSHIFT(r) \
  359. !     (reloc_target_rightshift[(int) (r)->r_type])
  360. ! #define RELOC_TARGET_SIZE(r)            (reloc_target_size[(int) (r)->r_type])
  361.   #define RELOC_TARGET_BITPOS(r)          0
  362. ! #define RELOC_TARGET_BITSIZE(r) \
  363. !     (reloc_target_bitsize[(int) (r)->r_type])
  364.   
  365.   /* Note that these are very dependent on the order of the enums in
  366.      enum reloc_type (in a.out.h); if they change the following must be
  367. ***************
  368. *** 813,818 ****
  369.      and reduce the size of the bss section to match.  */
  370.   int specified_data_size;
  371.   
  372.   /* Magic number to use for the output file, set by switch.  */
  373.   int magic;
  374.   
  375. --- 974,985 ----
  376.      and reduce the size of the bss section to match.  */
  377.   int specified_data_size;
  378.   
  379. + /* Gap to insert between end of bss and start of data seg */
  380. + int data_gap;
  381. + 
  382. + /* Nonzero if -Z was specified (for data_gap) */
  383. + int Z_flag_specified;
  384. + 
  385.   /* Magic number to use for the output file, set by switch.  */
  386.   int magic;
  387.   
  388. ***************
  389. *** 905,921 ****
  390.   char *concat ();
  391.   char *get_file_name ();
  392.   symbol *getsym (), *getsym_soft ();
  393. ! 
  394.   int
  395.   main (argc, argv)
  396.        char **argv;
  397.        int argc;
  398.   {
  399.     page_size = getpagesize ();
  400.     progname = argv[0];
  401.   
  402.     /* Clear the cumulative info on the output file.  */
  403. - 
  404.     text_size = 0;
  405.     data_size = 0;
  406.     bss_size = 0;
  407. --- 1072,1105 ----
  408.   char *concat ();
  409.   char *get_file_name ();
  410.   symbol *getsym (), *getsym_soft ();
  411. ! 
  412.   int
  413.   main (argc, argv)
  414.        char **argv;
  415.        int argc;
  416.   {
  417. + /*   Added this to stop ld core-dumping on very large .o files.    */
  418. + #ifdef RLIMIT_STACK
  419. +   /* Get rid of any avoidable limit on stack size.  */
  420. +   {
  421. +       struct rlimit rlim;
  422. + 
  423. +       /* Set the stack limit huge so that alloca does not fail. */
  424. +       getrlimit (RLIMIT_STACK, &rlim);
  425. +       rlim.rlim_cur = rlim.rlim_max;
  426. +       setrlimit (RLIMIT_STACK, &rlim);
  427. +   }
  428. + #endif /* RLIMIT_STACK */
  429. + 
  430. + #ifdef TARGET_PAGE_SIZE
  431. +   page_size = TARGET_PAGE_SIZE;
  432. + #else
  433.     page_size = getpagesize ();
  434. + #endif
  435. + 
  436.     progname = argv[0];
  437.   
  438.     /* Clear the cumulative info on the output file.  */
  439.     text_size = 0;
  440.     data_size = 0;
  441.     bss_size = 0;
  442. ***************
  443. *** 994,999 ****
  444.   
  445.     text_size -= N_TXTOFF (outheader);
  446.   
  447.     if (text_size < 0)
  448.       text_size = 0;
  449.     entry_offset = text_size;
  450. --- 1179,1187 ----
  451.   
  452.     text_size -= N_TXTOFF (outheader);
  453.   
  454. +   if (T_flag_specified)
  455. +       text_size = 0;    /* don't add sizeof(exec) at -T location */
  456. + 
  457.     if (text_size < 0)
  458.       text_size = 0;
  459.     entry_offset = text_size;
  460. ***************
  461. *** 1056,1061 ****
  462.       case 'u':
  463.       case 'V':
  464.       case 'y':
  465.         if (arg[2])
  466.       return 1;
  467.         return 2;
  468. --- 1244,1250 ----
  469.       case 'u':
  470.       case 'V':
  471.       case 'y':
  472. +     case 'Z':
  473.         if (arg[2])
  474.       return 1;
  475.         return 2;
  476. ***************
  477. *** 1072,1077 ****
  478.         if (! strcmp (&arg[2], "data"))
  479.       return 2;
  480.         return 1;
  481.       }
  482.   
  483.     return 1;
  484. --- 1261,1275 ----
  485.         if (! strcmp (&arg[2], "data"))
  486.       return 2;
  487.         return 1;
  488. + 
  489. + #if TARGET==TARGET_SEQUENT      
  490. +       /* k == Symmetry standalone,
  491. +        * p == don't align text/data boundary (for 8K disk bootstraps).
  492. +        */
  493. +    case 'k':
  494. +    case 'p':
  495. +        return 1;
  496. + #endif       
  497.       }
  498.   
  499.     return 1;
  500. ***************
  501. *** 1168,1180 ****
  502.   
  503.     /* Now check some option settings for consistency.  */
  504.   
  505.   #ifdef NMAGIC
  506.     if ((magic == ZMAGIC || magic == NMAGIC)
  507.   #else
  508. !   if ((magic == ZMAGIC)
  509.   #endif
  510.         && (text_start - text_start_alignment) & (page_size - 1))
  511.       fatal ("-T argument not multiple of page size, with sharable output", 0);
  512.   
  513.     /* Append the standard search directories to the user-specified ones.  */
  514.     {
  515. --- 1366,1384 ----
  516.   
  517.     /* Now check some option settings for consistency.  */
  518.   
  519. + #ifndef sprite
  520.   #ifdef NMAGIC
  521.     if ((magic == ZMAGIC || magic == NMAGIC)
  522.   #else
  523. ! #ifdef SMAGIC
  524. !     if ((magic == SMAGIC || magic == ZMAGIC)
  525. ! #else
  526. !     if ((magic == ZMAGIC)
  527. ! #endif /* SMAGIC */
  528.   #endif
  529.         && (text_start - text_start_alignment) & (page_size - 1))
  530.       fatal ("-T argument not multiple of page size, with sharable output", 0);
  531. + #endif
  532.   
  533.     /* Append the standard search directories to the user-specified ones.  */
  534.     {
  535. ***************
  536. *** 1250,1255 ****
  537.       return;
  538.     if (! strcmp (swt + 1, "Ttext"))
  539.       {
  540.         text_start = parse (arg, "%x", "invalid argument to -Ttext");
  541.         T_flag_specified = 1;
  542.         return;
  543. --- 1454,1462 ----
  544.       return;
  545.     if (! strcmp (swt + 1, "Ttext"))
  546.       {
  547. + #ifdef sprite 
  548. +       magic = OMAGIC;
  549. + #endif
  550.         text_start = parse (arg, "%x", "invalid argument to -Ttext");
  551.         T_flag_specified = 1;
  552.         return;
  553. ***************
  554. *** 1290,1296 ****
  555.         add_cmdline_ref (entry_symbol);
  556.         return;
  557.   
  558.       case 'l':
  559.         return;
  560.   
  561.       case 'L':
  562. --- 1497,1518 ----
  563.         add_cmdline_ref (entry_symbol);
  564.         return;
  565.   
  566. + #if TARGET==TARGET_SEQUENT
  567. +     case 'k':
  568. + #ifdef SMAGIC
  569. +       magic = SMAGIC;
  570. + #else
  571. +       fatal("No SMAGIC defined for -k");
  572. + #endif
  573. +       return;
  574. + #endif
  575. + 
  576.       case 'l':
  577. + #ifndef NO_C_PLUS_PLUS
  578. +       /* If linking with libg++, use the C++ demangler. */
  579. +       if (arg != NULL && strcmp (arg, "g++") == 0)
  580. +       demangler = cplus_demangle;
  581. + #endif /* NO_C_PLUS_PLUS */
  582.         return;
  583.   
  584.       case 'L':
  585. ***************
  586. *** 1333,1338 ****
  587.         return;
  588.   
  589.       case 'T':
  590.         text_start = parse (arg, "%x", "invalid argument to -T");
  591.         T_flag_specified = 1;
  592.         return;
  593. --- 1555,1563 ----
  594.         return;
  595.   
  596.       case 'T':
  597. + #ifdef sprite
  598. +       magic = OMAGIC;
  599. + #endif      
  600.         text_start = parse (arg, "%x", "invalid argument to -T");
  601.         T_flag_specified = 1;
  602.         return;
  603. ***************
  604. *** 4288,4294 ****
  605.   
  606.      FUNCTION receives two arguments: the entry, and ARG.  It must be a
  607.      function returning unsigned long (though this can probably be fudged). */
  608. ! 
  609.   unsigned long
  610.   check_each_file (function, arg)
  611.        register unsigned long (*function)();
  612. --- 4520,4526 ----
  613.   
  614.      FUNCTION receives two arguments: the entry, and ARG.  It must be a
  615.      function returning unsigned long (though this can probably be fudged). */
  616. ! #if 0
  617.   unsigned long
  618.   check_each_file (function, arg)
  619.        register unsigned long (*function)();
  620. ***************
  621. *** 1493,1499 ****
  622.   
  623.     if (entry->search_dirs_flag)
  624.       {
  625. -       register char **p = search_dirs;
  626.         int i;
  627.   
  628.         for (i = 0; i < n_search_dirs; i++)
  629. --- 1726,1731 ----
  630.   
  631.     if (entry->search_dirs_flag)
  632.       {
  633.         int i;
  634.   
  635.         for (i = 0; i < n_search_dirs; i++)
  636. ***************
  637. *** 1593,1598 ****
  638.     len = read (desc, loc, sizeof (struct exec));
  639.     if (len != sizeof (struct exec))
  640.       fatal_with_file ("failure reading header of ", entry);
  641.     if (N_BADMAG (*loc))
  642.       fatal_with_file ("bad magic number in ", entry);
  643.   
  644. --- 1825,1833 ----
  645.     len = read (desc, loc, sizeof (struct exec));
  646.     if (len != sizeof (struct exec))
  647.       fatal_with_file ("failure reading header of ", entry);
  648. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  649. +   fix_exec_header_byte_order(loc);
  650. + #endif
  651.     if (N_BADMAG (*loc))
  652.       fatal_with_file ("bad magic number in ", entry);
  653.   
  654. ***************
  655. *** 1619,1629 ****
  656.     lseek (desc, N_SYMOFF (entry->header) + entry->starting_offset, 0);
  657.     if (entry->header.a_syms != read (desc, entry->symbols, entry->header.a_syms))
  658.       fatal_with_file ("premature end of file in symbols of ", entry);
  659. ! 
  660.     lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0);
  661.     if (sizeof str_size != read (desc, &str_size, sizeof str_size))
  662.       fatal_with_file ("bad string table size in ", entry);
  663. ! 
  664.     entry->string_size = str_size;
  665.   }
  666.   
  667. --- 1854,1868 ----
  668.     lseek (desc, N_SYMOFF (entry->header) + entry->starting_offset, 0);
  669.     if (entry->header.a_syms != read (desc, entry->symbols, entry->header.a_syms))
  670.       fatal_with_file ("premature end of file in symbols of ", entry);
  671. ! #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  672. !   fix_symbol_byte_order(entry->symbols, entry->header.a_syms);
  673. ! #endif
  674.     lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0);
  675.     if (sizeof str_size != read (desc, &str_size, sizeof str_size))
  676.       fatal_with_file ("bad string table size in ", entry);
  677. ! #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  678. !   fix_byte_order(&str_size, sizeof(str_size));
  679. ! #endif
  680.     entry->string_size = str_size;
  681.   }
  682.   
  683. ***************
  684. *** 1703,1709 ****
  685.     len = read (desc, &hdr, sizeof hdr);
  686.     if (len != sizeof hdr)
  687.       fatal_with_file ("failure reading header of ", entry);
  688. ! 
  689.     if (!N_BADMAG (hdr))
  690.       {
  691.         read_entry_symbols (desc, entry);
  692. --- 1942,1950 ----
  693.     len = read (desc, &hdr, sizeof hdr);
  694.     if (len != sizeof hdr)
  695.       fatal_with_file ("failure reading header of ", entry);
  696. ! #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  697. !   fix_exec_header_byte_order(&hdr);
  698. ! #endif
  699.     if (!N_BADMAG (hdr))
  700.       {
  701.         read_entry_symbols (desc, entry);
  702. ***************
  703. *** 1735,1741 ****
  704.     register struct nlist
  705.       *p,
  706.       *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  707. -   int lowest_set_vector = -1;
  708.   
  709.     if (trace_files) prline_file_name (entry, stderr);
  710.   
  711. --- 1976,1981 ----
  712.     register struct nlist
  713.       *p,
  714.       *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  715.   
  716.     if (trace_files) prline_file_name (entry, stderr);
  717.   
  718. ***************
  719. *** 2179,2185 ****
  720.      all such structs that refer to the same global symbol.
  721.      This chain starts in the `refs' field of the symbol table entry
  722.      and is chained through the `n_name'.  */
  723. - 
  724.   void
  725.   enter_global_ref (nlist_p, name, entry)
  726.        register struct nlist *nlist_p;
  727. --- 2418,2423 ----
  728.      all such structs that refer to the same global symbol.
  729.      This chain starts in the `refs' field of the symbol table entry
  730.      and is chained through the `n_name'.  */
  731.   void
  732.   enter_global_ref (nlist_p, name, entry)
  733.        register struct nlist *nlist_p;
  734. ***************
  735. *** 2232,2239 ****
  736.       {
  737.         /* Indirect symbols value should be modified to point
  738.            a symbol being equivalenced to. */
  739. !       nlist_p->n_value
  740. !         = (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx
  741.                        + entry->strings);
  742.         if ((symbol *) nlist_p->n_value == sp)
  743.           {
  744. --- 2470,2477 ----
  745.       {
  746.         /* Indirect symbols value should be modified to point
  747.            a symbol being equivalenced to. */
  748. !       nlist_p->n_value =
  749. !         (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx
  750.                        + entry->strings);
  751.         if ((symbol *) nlist_p->n_value == sp)
  752.           {
  753. ***************
  754. *** 2703,2709 ****
  755.        potentially want it.  */
  756.         if (type & N_EXT
  757.         && (type != (N_UNDF | N_EXT) || p->n_value
  758. !           
  759.   #ifdef DOLLAR_KLUDGE
  760.              || name[1] == '$'
  761.   #endif
  762. --- 2955,2961 ----
  763.        potentially want it.  */
  764.         if (type & N_EXT
  765.         && (type != (N_UNDF | N_EXT) || p->n_value
  766. ! 
  767.   #ifdef DOLLAR_KLUDGE
  768.              || name[1] == '$'
  769.   #endif
  770. ***************
  771. *** 2435,2443 ****
  772.   
  773.   #ifdef NMAGIC
  774.     if (magic == ZMAGIC || magic == NMAGIC)
  775. ! #else
  776.     if (magic == ZMAGIC)
  777. ! #endif
  778.       {
  779.         int text_end = text_size + N_TXTOFF (outheader);
  780.         text_pad = ((text_end + page_size - 1) & (- page_size)) - text_end;
  781. --- 2712,2724 ----
  782.   
  783.   #ifdef NMAGIC
  784.     if (magic == ZMAGIC || magic == NMAGIC)
  785. ! #else /* NMAGIC */
  786. ! #ifdef SMAGIC
  787. !   if (magic == ZMAGIC || magic == SMAGIC)
  788. ! #else /* SMAGIC */
  789.     if (magic == ZMAGIC)
  790. ! #endif /* SMAGIC */
  791. ! #endif /* NMAGIC */
  792.       {
  793.         int text_end = text_size + N_TXTOFF (outheader);
  794.         text_pad = ((text_end + page_size - 1) & (- page_size)) - text_end;
  795. ***************
  796. *** 3776,3785 ****
  797.   
  798.     if (! Tdata_flag_specified)
  799.       data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  800. ! 
  801.     /* Make sure bss starts out aligned as much as anyone can want.  */
  802.   
  803.     data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  804.   
  805.     /* Set up the set element vector */
  806.   
  807. --- 4057,4070 ----
  808.   
  809.     if (! Tdata_flag_specified)
  810.       data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  811. ! #ifdef foobar
  812.     /* Make sure bss starts out aligned as much as anyone can want.  */
  813.   
  814.     data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  815. + #endif
  816. + 
  817. +   if (Z_flag_specified)
  818. +       data_start += data_gap;
  819.   
  820.     /* Set up the set element vector */
  821.   
  822. ***************
  823. *** 3789,3800 ****
  824.            for each symbol for the length word at the beginning of the
  825.        vector, plus a word for each symbol for a zero at the end of
  826.        the vector (for incremental linking).  */
  827. !       set_sect_size
  828. !     = (2 * set_symbol_count + set_vector_count) * sizeof (unsigned long);
  829.         set_sect_start = data_start + data_size;
  830.         data_size += set_sect_size;
  831.         set_vectors = (unsigned long *) xmalloc (set_sect_size);
  832.         setv_fill_count = 0;
  833.       }
  834.   
  835.     /* Compute start addresses of each file's sections and symbols.  */
  836. --- 4074,4087 ----
  837.            for each symbol for the length word at the beginning of the
  838.        vector, plus a word for each symbol for a zero at the end of
  839.        the vector (for incremental linking).  */
  840. !       set_sect_size =
  841. !         (2 * set_symbol_count + set_vector_count) * sizeof (unsigned long);
  842.         set_sect_start = data_start + data_size;
  843.         data_size += set_sect_size;
  844.         set_vectors = (unsigned long *) xmalloc (set_sect_size);
  845. + #if 1
  846.         setv_fill_count = 0;
  847. + #endif      
  848.       }
  849.   
  850.     /* Compute start addresses of each file's sections and symbols.  */
  851. ***************
  852. *** 3819,3825 ****
  853.       {
  854.         /* For each symbol */
  855.         register struct nlist *p, *next;
  856. !       int defs = 0, com = sp->max_common_size, erred = 0;
  857.         struct nlist *first_definition;
  858.         for (p = sp->refs; p; p = next)
  859.           {
  860. --- 4106,4112 ----
  861.       {
  862.         /* For each symbol */
  863.         register struct nlist *p, *next;
  864. !       int defs = 0, com = sp->max_common_size;
  865.         struct nlist *first_definition;
  866.         for (p = sp->refs; p; p = next)
  867.           {
  868. ***************
  869. *** 3901,3913 ****
  870.            Reverse the vector itself to put it in file order.  */
  871.         if ((sp->defined & ~N_EXT) == N_SETV)
  872.           {
  873. !           unsigned long length_word_index
  874. !         = (sp->value - set_sect_start) / sizeof (unsigned long);
  875.             unsigned long i, tmp;
  876.   
  877. !           set_vectors[length_word_index]
  878. !         = setv_fill_count - 1 - length_word_index;
  879. ! 
  880.             /* Reverse the vector.  */
  881.             for (i = 1;
  882.              i < (setv_fill_count - length_word_index - 1) / 2 + 1;
  883. --- 4188,4199 ----
  884.            Reverse the vector itself to put it in file order.  */
  885.         if ((sp->defined & ~N_EXT) == N_SETV)
  886.           {
  887. !           unsigned long length_word_index =
  888. !             (sp->value - set_sect_start) / sizeof (unsigned long);
  889.             unsigned long i, tmp;
  890.   
  891. !           set_vectors[length_word_index] =
  892. !             setv_fill_count - 1 - length_word_index;
  893.             /* Reverse the vector.  */
  894.             for (i = 1;
  895.              i < (setv_fill_count - length_word_index - 1) / 2 + 1;
  896. ***************
  897. *** 3914,3921 ****
  898.              i++)
  899.           {
  900.             tmp = set_vectors[length_word_index + i];
  901. !           set_vectors[length_word_index + i]
  902. !             = set_vectors[setv_fill_count - i];
  903.             set_vectors[setv_fill_count - i] = tmp;
  904.           }
  905.   
  906. --- 4200,4207 ----
  907.              i++)
  908.           {
  909.             tmp = set_vectors[length_word_index + i];
  910. !           set_vectors[length_word_index + i] =
  911. !             set_vectors[setv_fill_count - i];
  912.             set_vectors[setv_fill_count - i] = tmp;
  913.           }
  914.   
  915. ***************
  916. *** 3926,3934 ****
  917.       }
  918.       }
  919.   
  920.     /* Make sure end of bss is aligned as much as anyone can want.  */
  921.   
  922.     bss_size = (bss_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  923.   
  924.     if (end_symbol)        /* These are null if -r.  */
  925.       {
  926. --- 4212,4222 ----
  927.       }
  928.       }
  929.   
  930. + #ifdef foobar
  931.     /* Make sure end of bss is aligned as much as anyone can want.  */
  932.   
  933.     bss_size = (bss_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  934. + #endif
  935.   
  936.     if (end_symbol)        /* These are null if -r.  */
  937.       {
  938. ***************
  939. *** 3942,3950 ****
  940.     if (specified_data_size && specified_data_size > data_size)
  941.       data_pad = specified_data_size - data_size;
  942.   
  943.     if (magic == ZMAGIC)
  944.       data_pad = ((data_pad + data_size + page_size - 1) & (- page_size))
  945. !                - data_size;
  946.   
  947.     bss_size -= data_pad;
  948.     if (bss_size < 0) bss_size = 0;
  949. --- 4230,4242 ----
  950.     if (specified_data_size && specified_data_size > data_size)
  951.       data_pad = specified_data_size - data_size;
  952.   
  953. + #ifdef SMAGIC
  954. +   if (magic == SMAGIC || magic == ZMAGIC)
  955. + #else
  956.     if (magic == ZMAGIC)
  957. + #endif
  958.       data_pad = ((data_pad + data_size + page_size - 1) & (- page_size))
  959. !     - data_size;
  960.   
  961.     bss_size -= data_pad;
  962.     if (bss_size < 0) bss_size = 0;
  963. ***************
  964. *** 4114,4120 ****
  965.   {
  966.     int line;
  967.     char *filename;
  968. !   struct nlist *sym;
  969.   };
  970.   
  971.   void qsort ();
  972. --- 4406,4412 ----
  973.   {
  974.     int line;
  975.     char *filename;
  976. !   struct nlist *Sym;
  977.   };
  978.   
  979.   void qsort ();
  980. ***************
  981. *** 4150,4176 ****
  982.       *next = state_pointer + 1,
  983.       /* Used to store source file */
  984.       *source = state_pointer + 2;
  985. !   struct file_entry *entry = (struct file_entry *) source->sym;
  986.   
  987. !   current->sym = next->sym;
  988.     current->line = next->line;
  989.     current->filename = next->filename;
  990.   
  991. !   while (++(next->sym) < (entry->symbols
  992.                 + entry->header.a_syms/sizeof (struct nlist)))
  993.       {
  994.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  995.          * may look negative...therefore, must mask to low bits
  996.          */
  997. !       switch (next->sym->n_type & 0xff) 
  998.       {
  999.       case N_SLINE:
  1000.         if (use_data_symbols) continue;
  1001. !       next->line = next->sym->n_desc;
  1002.         return 1;
  1003.       case N_DSLINE:
  1004.         if (!use_data_symbols) continue;
  1005. !       next->line = next->sym->n_desc;
  1006.         return 1;
  1007.   #ifdef HAVE_SUN_STABS
  1008.       case N_EINCL:
  1009. --- 4442,4468 ----
  1010.       *next = state_pointer + 1,
  1011.       /* Used to store source file */
  1012.       *source = state_pointer + 2;
  1013. !   struct file_entry *entry = (struct file_entry *) source->Sym;
  1014.   
  1015. !   current->Sym = next->Sym;
  1016.     current->line = next->line;
  1017.     current->filename = next->filename;
  1018.   
  1019. !   while (++(next->Sym) < (entry->symbols
  1020.                 + entry->header.a_syms/sizeof (struct nlist)))
  1021.       {
  1022.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  1023.          * may look negative...therefore, must mask to low bits
  1024.          */
  1025. !       switch (next->Sym->n_type & 0xff) 
  1026.       {
  1027.       case N_SLINE:
  1028.         if (use_data_symbols) continue;
  1029. !       next->line = next->Sym->n_desc;
  1030.         return 1;
  1031.       case N_DSLINE:
  1032.         if (!use_data_symbols) continue;
  1033. !       next->line = next->Sym->n_desc;
  1034.         return 1;
  1035.   #ifdef HAVE_SUN_STABS
  1036.       case N_EINCL:
  1037. ***************
  1038. *** 4178,4196 ****
  1039.         continue;
  1040.   #endif
  1041.       case N_SO:
  1042. !       source->filename = next->sym->n_un.n_strx + entry->strings;
  1043.         source->line++;
  1044.   #ifdef HAVE_SUN_STABS
  1045.       case N_BINCL:
  1046.   #endif
  1047.       case N_SOL:
  1048. !       next->filename
  1049. !         = next->sym->n_un.n_strx + entry->strings;
  1050.       default:
  1051.         continue;
  1052.       }
  1053.       }
  1054. !   next->sym = (struct nlist *) 0;
  1055.     return 0;
  1056.   }
  1057.   
  1058. --- 4470,4488 ----
  1059.         continue;
  1060.   #endif
  1061.       case N_SO:
  1062. !       source->filename = next->Sym->n_un.n_strx + entry->strings;
  1063.         source->line++;
  1064.   #ifdef HAVE_SUN_STABS
  1065.       case N_BINCL:
  1066.   #endif
  1067.       case N_SOL:
  1068. !       next->filename =
  1069. !         next->Sym->n_un.n_strx + entry->strings;
  1070.       default:
  1071.         continue;
  1072.       }
  1073.       }
  1074. !   next->Sym = (struct nlist *) 0;
  1075.     return 0;
  1076.   }
  1077.   
  1078. ***************
  1079. *** 4205,4213 ****
  1080.        struct file_entry *entry;
  1081.   {
  1082.     struct line_debug_entry
  1083. !     *state_pointer
  1084. !       = (struct line_debug_entry *)
  1085. !     xmalloc (3 * sizeof (struct line_debug_entry));
  1086.     register struct line_debug_entry
  1087.       *current = state_pointer,
  1088.       *next = state_pointer + 1,
  1089. --- 4497,4505 ----
  1090.        struct file_entry *entry;
  1091.   {
  1092.     struct line_debug_entry
  1093. !     *state_pointer =
  1094. !         (struct line_debug_entry *)
  1095. !         xmalloc (3 * sizeof (struct line_debug_entry));
  1096.     register struct line_debug_entry
  1097.       *current = state_pointer,
  1098.       *next = state_pointer + 1,
  1099. ***************
  1100. *** 4228,4234 ****
  1101.         /* I believe this translates to "We lose" */
  1102.         current->filename = next->filename = entry->filename;
  1103.         current->line = next->line = -1;
  1104. !       current->sym = next->sym = (struct nlist *) 0;
  1105.         return state_pointer;
  1106.       }
  1107.   
  1108. --- 4520,4526 ----
  1109.         /* I believe this translates to "We lose" */
  1110.         current->filename = next->filename = entry->filename;
  1111.         current->line = next->line = -1;
  1112. !       current->Sym = next->Sym = (struct nlist *) 0;
  1113.         return state_pointer;
  1114.       }
  1115.   
  1116. ***************
  1117. *** 4235,4246 ****
  1118.     next->line = source->line = 0;
  1119.     next->filename = source->filename
  1120.       = (tmp->n_un.n_strx + entry->strings);
  1121. !   source->sym = (struct nlist *) entry;
  1122. !   next->sym = tmp;
  1123.   
  1124.     next_debug_entry (use_data_symbols, state_pointer); /* To setup next */
  1125.   
  1126. !   if (!next->sym)        /* No line numbers for this section; */
  1127.                   /* setup output results as appropriate */
  1128.       {
  1129.         if (source->line)
  1130. --- 4527,4538 ----
  1131.     next->line = source->line = 0;
  1132.     next->filename = source->filename
  1133.       = (tmp->n_un.n_strx + entry->strings);
  1134. !   source->Sym = (struct nlist *) entry;
  1135. !   next->Sym = tmp;
  1136.   
  1137.     next_debug_entry (use_data_symbols, state_pointer); /* To setup next */
  1138.   
  1139. !   if (!next->Sym)        /* No line numbers for this section; */
  1140.                   /* setup output results as appropriate */
  1141.       {
  1142.         if (source->line)
  1143. ***************
  1144. *** 4280,4296 ****
  1145.   
  1146.     int use_data_symbols;
  1147.   
  1148. !   if (next->sym)
  1149. !     use_data_symbols = (next->sym->n_type & N_TYPE) == N_DATA;
  1150.     else
  1151.       return current->line;
  1152.   
  1153.     /* Go back to the beginning if we've already passed it.  */
  1154. !   if (current->sym->n_value > address)
  1155.       {
  1156.         tmp_pointer = init_debug_scan (use_data_symbols,
  1157.                        (struct file_entry *)
  1158. !                      ((state_pointer + 2)->sym));
  1159.         state_pointer[0] = tmp_pointer[0];
  1160.         state_pointer[1] = tmp_pointer[1];
  1161.         state_pointer[2] = tmp_pointer[2];
  1162. --- 4572,4588 ----
  1163.   
  1164.     int use_data_symbols;
  1165.   
  1166. !   if (next->Sym)
  1167. !     use_data_symbols = (next->Sym->n_type & N_TYPE) == N_DATA;
  1168.     else
  1169.       return current->line;
  1170.   
  1171.     /* Go back to the beginning if we've already passed it.  */
  1172. !   if (current->Sym->n_value > address)
  1173.       {
  1174.         tmp_pointer = init_debug_scan (use_data_symbols,
  1175.                        (struct file_entry *)
  1176. !                      ((state_pointer + 2)->Sym));
  1177.         state_pointer[0] = tmp_pointer[0];
  1178.         state_pointer[1] = tmp_pointer[1];
  1179.         state_pointer[2] = tmp_pointer[2];
  1180. ***************
  1181. *** 4298,4308 ****
  1182.       }
  1183.   
  1184.     /* If we're still in a bad way, return -1, meaning invalid line.  */
  1185. !   if (current->sym->n_value > address)
  1186.       return -1;
  1187.   
  1188. !   while (next->sym
  1189. !      && next->sym->n_value <= address
  1190.        && next_debug_entry (use_data_symbols, state_pointer))
  1191.       ;
  1192.     return current->line;
  1193. --- 4590,4600 ----
  1194.       }
  1195.   
  1196.     /* If we're still in a bad way, return -1, meaning invalid line.  */
  1197. !   if (current->Sym->n_value > address)
  1198.       return -1;
  1199.   
  1200. !   while (next->Sym
  1201. !      && next->Sym->n_value <= address
  1202.        && next_debug_entry (use_data_symbols, state_pointer))
  1203.       ;
  1204.     return current->line;
  1205. ***************
  1206. *** 4332,4349 ****
  1207.     struct relocation_info
  1208.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  1209.       *reloc;
  1210. !   int reloc_size
  1211. !     = ((data_segment ? entry->header.a_drsize : entry->header.a_trsize)
  1212. !        / sizeof (struct relocation_info));
  1213. !   int start_of_segment
  1214. !     = (data_segment ? entry->data_start_address : entry->text_start_address);
  1215.     struct nlist *start_of_syms = entry->symbols;
  1216. !   struct line_debug_entry *state_pointer
  1217. !     = init_debug_scan (data_segment != 0, entry);
  1218.     register struct line_debug_entry
  1219. !     *current = state_pointer,
  1220. !     *next = state_pointer + 1,
  1221. !     *source = state_pointer + 2;
  1222.     /* Assigned to generally static values; should not be written into.  */
  1223.     char *errfmt;
  1224.     /* Assigned to alloca'd values cand copied into; should be freed
  1225. --- 4624,4639 ----
  1226.     struct relocation_info
  1227.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  1228.       *reloc;
  1229. !   int reloc_size =
  1230. !     (data_segment ? entry->header.a_drsize : entry->header.a_trsize)
  1231. !        / sizeof (struct relocation_info);
  1232. !   int start_of_segment =
  1233. !     (data_segment ? entry->data_start_address : entry->text_start_address);
  1234.     struct nlist *start_of_syms = entry->symbols;
  1235. !   struct line_debug_entry *state_pointer =
  1236. !     init_debug_scan (data_segment != 0, entry);
  1237.     register struct line_debug_entry
  1238. !     *current = state_pointer;
  1239.     /* Assigned to generally static values; should not be written into.  */
  1240.     char *errfmt;
  1241.     /* Assigned to alloca'd values cand copied into; should be freed
  1242. ***************
  1243. *** 4421,4428 ****
  1244.         /* If errfmt == 0, errmsg has already been defined.  */
  1245.         if (errfmt != 0)
  1246.       {
  1247. !       errmsg = (char *) xmalloc (strlen (errfmt) + strlen (g->name) + 1);
  1248. !       sprintf (errmsg, errfmt, g->name, data_segment ? "data" : "text");
  1249.       }
  1250.   
  1251.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  1252. --- 4711,4724 ----
  1253.         /* If errfmt == 0, errmsg has already been defined.  */
  1254.         if (errfmt != 0)
  1255.       {
  1256. !       char *nm;
  1257. ! 
  1258. !       if (demangler == NULL || (nm = (*demangler)(g->name)) == NULL)
  1259. !         nm = g->name;
  1260. !       errmsg = (char *) xmalloc (strlen (errfmt) + strlen (nm) + 1);
  1261. !       sprintf (errmsg, errfmt, nm, data_segment ? "data" : "text");
  1262. !       if (nm != g->name)
  1263. !         free (nm);
  1264.       }
  1265.   
  1266.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  1267. ***************
  1268. *** 4451,4458 ****
  1269.        FILE *outfile;
  1270.   {
  1271.     int number_of_syms = entry->header.a_syms / sizeof (struct nlist);
  1272. !   unsigned char *nlist_bitvector
  1273. !     = (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  1274.     struct line_debug_entry *text_scan, *data_scan;
  1275.     int i;
  1276.     char *errfmt, *file_name;
  1277. --- 4747,4754 ----
  1278.        FILE *outfile;
  1279.   {
  1280.     int number_of_syms = entry->header.a_syms / sizeof (struct nlist);
  1281. !   unsigned char *nlist_bitvector =
  1282. !     (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  1283.     struct line_debug_entry *text_scan, *data_scan;
  1284.     int i;
  1285.     char *errfmt, *file_name;
  1286. ***************
  1287. *** 4530,4536 ****
  1288.       {
  1289.         if (g->undef_refs >= MAX_UREFS_PRINTED)
  1290.           continue;
  1291. !       
  1292.         if (++(g->undef_refs) == MAX_UREFS_PRINTED)
  1293.           errfmt = "More undefined \"%s\" refs follow";
  1294.         else
  1295. --- 4826,4832 ----
  1296.       {
  1297.         if (g->undef_refs >= MAX_UREFS_PRINTED)
  1298.           continue;
  1299. ! 
  1300.         if (++(g->undef_refs) == MAX_UREFS_PRINTED)
  1301.           errfmt = "More undefined \"%s\" refs follow";
  1302.         else
  1303. ***************
  1304. *** 4553,4559 ****
  1305.       }
  1306.         else
  1307.       continue;
  1308. !       
  1309.         if (line_number == -1)
  1310.       fprintf (outfile, "%s: ", entry->filename);
  1311.         else
  1312. --- 4849,4855 ----
  1313.       }
  1314.         else
  1315.       continue;
  1316. ! 
  1317.         if (line_number == -1)
  1318.       fprintf (outfile, "%s: ", entry->filename);
  1319.         else
  1320. ***************
  1321. *** 4560,4568 ****
  1322.       fprintf (outfile, "%s:%d: ", file_name, line_number);
  1323.   
  1324.         if (dont_allow_symbol_name)
  1325. !     fprintf (outfile, "%s", errfmt);
  1326.         else
  1327. !     fprintf (outfile, errfmt, g->name);
  1328.   
  1329.         fputc ('\n', outfile);
  1330.       }
  1331. --- 4856,4872 ----
  1332.       fprintf (outfile, "%s:%d: ", file_name, line_number);
  1333.   
  1334.         if (dont_allow_symbol_name)
  1335. !       fprintf (outfile, "%s", errfmt);
  1336.         else
  1337. !       {
  1338. !     char *nm;
  1339. !     if (demangler != NULL && (nm = (*demangler)(g->name)) != NULL)
  1340. !       {
  1341. !         fprintf (outfile, errfmt, nm);
  1342. !         free (nm);
  1343. !       } else
  1344. !         fprintf (outfile, errfmt, g->name);
  1345. !       }
  1346.   
  1347.         fputc ('\n', outfile);
  1348.       }
  1349. ***************
  1350. *** 4587,4593 ****
  1351.       return;
  1352.   
  1353.     each_file (do_file_warnings, outfile);
  1354. ! 
  1355.     if (list_unresolved_refs || list_multiple_defs)
  1356.       make_executable = 0;
  1357.   }
  1358. --- 4891,4899 ----
  1359.       return;
  1360.   
  1361.     each_file (do_file_warnings, outfile);
  1362. !   if (trace_files)
  1363. !       printf("undefined_global_sym_count= %d, multiple_def_count= %d\n",
  1364. !          undefined_global_sym_count, multiple_def_count);
  1365.     if (list_unresolved_refs || list_multiple_defs)
  1366.       make_executable = 0;
  1367.   }
  1368. ***************
  1369. *** 4640,4647 ****
  1370.   {
  1371.     N_SET_MAGIC (outheader, magic);
  1372.     outheader.a_text = text_size;
  1373. ! #ifdef sequent
  1374.     outheader.a_text += N_ADDRADJ (outheader);
  1375.   #endif
  1376.     outheader.a_data = data_size;
  1377.     outheader.a_bss = bss_size;
  1378. --- 4946,4957 ----
  1379.   {
  1380.     N_SET_MAGIC (outheader, magic);
  1381.     outheader.a_text = text_size;
  1382. !   if (T_flag_specified)
  1383. !       outheader.a_text += text_start;
  1384. ! #if TARGET_MACHINE==TARGET_SEQUENT
  1385.     outheader.a_text += N_ADDRADJ (outheader);
  1386. +   if (entry_symbol == 0)
  1387. +       entry_symbol = getsym("start");
  1388.   #endif
  1389.     outheader.a_data = data_size;
  1390.     outheader.a_bss = bss_size;
  1391. ***************
  1392. *** 4709,4715 ****
  1393.         coffheader.data_start = dp->s_vaddr;
  1394.       }
  1395.   #endif
  1396.   
  1397.   #ifdef INITIALIZE_HEADER
  1398.     INITIALIZE_HEADER;
  1399.   #endif
  1400. --- 5019,5043 ----
  1401.         coffheader.data_start = dp->s_vaddr;
  1402.       }
  1403.   #endif
  1404. + #if TARGET==TARGET_SEQUENT
  1405. +     if (SMAGIC == magic) {
  1406. +     char *target_ptr; 
  1407. +     long n; 
  1408.   
  1409. +     outheader.a_gdtbl = gdt_filler; 
  1410. +     if (sizeof(instr) > sizeof(outheader.a_bootstrap)) {
  1411. +         fatal("a_bootstrap too small for code"); 
  1412. +     } 
  1413. +     n = outheader.a_entry; 
  1414. +     target_ptr = &instr[sizeof(instr) - 4];
  1415. +     target_ptr[0] = n & 0xff; 
  1416. +     target_ptr[1] = (n >> 8) & 0xff; 
  1417. +     target_ptr[2] = (n >> 16) & 0xff; 
  1418. +     target_ptr[3] = (n >> 24) & 0xff; 
  1419. +     bcopy(instr, (char *)outheader.a_bootstrap, sizeof(instr)); 
  1420. +     }
  1421. + #endif
  1422. + 
  1423.   #ifdef INITIALIZE_HEADER
  1424.     INITIALIZE_HEADER;
  1425.   #endif
  1426. ***************
  1427. *** 4749,4755 ****
  1428.     if (need_coff_header)
  1429.       mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  1430.   #endif
  1431.     mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  1432.   
  1433.     /* Output whatever padding is required in the executable file
  1434.        between the header and the start of the text.  */
  1435. --- 5077,5089 ----
  1436.     if (need_coff_header)
  1437.       mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  1438.   #endif
  1439. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1440. +   fix_exec_header_byte_order(&outheader);
  1441. + #endif
  1442.     mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  1443. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1444. +   fix_exec_header_byte_order(&outheader);
  1445. + #endif
  1446.   
  1447.     /* Output whatever padding is required in the executable file
  1448.        between the header and the start of the text.  */
  1449. ***************
  1450. *** 4748,4753 ****
  1451.            L_SET);
  1452.         if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1453.       fatal_with_file ("premature eof in data relocation of ", entry);
  1454.         entry->datarel = reloc;
  1455.       }
  1456.   }
  1457. --- 5091,5100 ----
  1458.            L_SET);
  1459.         if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1460.       fatal_with_file ("premature eof in data relocation of ", entry);
  1461. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1462. +       target_to_host_reloc_byte_order(reloc,
  1463. +     entry->header.a_drsize/sizeof(*reloc));
  1464. + #endif
  1465.         entry->datarel = reloc;
  1466.       }
  1467.   }
  1468. ***************
  1469. *** 4784,4792 ****
  1470.     else
  1471.       {
  1472.         reloc = (struct relocation_info *) alloca (entry->header.a_trsize);
  1473.         lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0);
  1474.         if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize))
  1475.       fatal_with_file ("premature eof in text relocation of ", entry);
  1476.       }
  1477.   
  1478.     /* Read the text section into core.  */
  1479. --- 5131,5148 ----
  1480.     else
  1481.       {
  1482.         reloc = (struct relocation_info *) alloca (entry->header.a_trsize);
  1483. +       if (trace_files)
  1484. +           printf("lseek to 0x%x (t_o= 0x%x, a_t= 0x%x, a_d= 0x%x)\n",
  1485. +              text_offset(entry) + entry->header.a_text +
  1486. +              entry->header.a_data, text_offset(entry),
  1487. +              entry->header.a_text, entry->header.a_data);
  1488.         lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0);
  1489.         if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize))
  1490.       fatal_with_file ("premature eof in text relocation of ", entry);
  1491. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1492. +       target_to_host_reloc_byte_order(reloc,
  1493. +       entry->header.a_trsize/sizeof(*reloc));
  1494. + #endif
  1495.       }
  1496.   
  1497.     /* Read the text section into core.  */
  1498. ***************
  1499. *** 3511,3516 ****
  1500.            0);
  1501.         if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1502.       fatal_with_file ("premature eof in data relocation of ", entry);
  1503.       }
  1504.   
  1505.     lseek (desc, text_offset (entry) + entry->header.a_text, 0);
  1506. --- 3876,3885 ----
  1507.            0);
  1508.         if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1509.       fatal_with_file ("premature eof in data relocation of ", entry);
  1510. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1511. +       target_to_host_reloc_byte_order(reloc,
  1512. +       entry->header.a_drsize/sizeof(*reloc));
  1513. + #endif
  1514.       }
  1515.   
  1516.     lseek (desc, text_offset (entry) + entry->header.a_text, 0);
  1517. ***************
  1518. *** 3661,3681 ****
  1519.         break;
  1520.   
  1521.       case 1:
  1522.         if (RELOC_MEMORY_SUB_P(p))
  1523. !         relocation -= mask & *(short *) (data + addr);
  1524.         else if (RELOC_MEMORY_ADD_P(p))
  1525. !         relocation += mask & *(short *) (data + addr);
  1526. !       *(short *) (data + addr) &= ~mask;
  1527. !       *(short *) (data + addr) |= relocation;
  1528.         break;
  1529.   
  1530.       case 2:
  1531. !       if (RELOC_MEMORY_SUB_P(p))
  1532. !         relocation -= mask & *(long *) (data + addr);
  1533.         else if (RELOC_MEMORY_ADD_P(p))
  1534. !         relocation += mask & *(long *) (data + addr);
  1535. !       *(long *) (data + addr) &= ~mask;
  1536. !       *(long *) (data + addr) |= relocation;
  1537.         break;
  1538.   
  1539.       default:
  1540. --- 4036,4096 ----
  1541.         break;
  1542.   
  1543.       case 1:
  1544. + #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1545. +       x = ((unsigned char *) (data + addr))[1]
  1546. +        | (((unsigned char *) (data + addr))[0] << 8);
  1547. + #endif
  1548. + #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1549. +       x = ((unsigned char *) (data + addr))[0]
  1550. +        | (((unsigned char *) (data + addr))[1] << 8);
  1551. + #endif
  1552.         if (RELOC_MEMORY_SUB_P(p))
  1553. !         relocation -= mask & x;
  1554.         else if (RELOC_MEMORY_ADD_P(p))
  1555. !         relocation += mask & x;
  1556. !       x &= ~mask;
  1557. !       x |= relocation;
  1558. ! #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1559. !       ((unsigned char *) (data + addr))[1] = x;
  1560. !       ((unsigned char *) (data + addr))[0] = x >> 8;
  1561. ! #endif
  1562. ! #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1563. !       ((unsigned char *) (data + addr))[0] = x;
  1564. !       ((unsigned char *) (data + addr))[1] = x >> 8;
  1565. ! #endif
  1566.         break;
  1567.   
  1568.       case 2:
  1569. ! #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1570. !       x = ((unsigned char *) (data + addr))[3]
  1571. !        | (((unsigned char *) (data + addr))[2] << 8)
  1572. !        | (((unsigned char *) (data + addr))[1] << 16)
  1573. !        | (((unsigned char *) (data + addr))[0] << 24);
  1574. ! #endif
  1575. ! #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1576. !       x = ((unsigned char *) (data + addr))[0]
  1577. !        | (((unsigned char *) (data + addr))[1] << 8)
  1578. !        | (((unsigned char *) (data + addr))[2] << 16)
  1579. !        | (((unsigned char *) (data + addr))[3] << 24);
  1580. ! #endif
  1581. !           if (RELOC_MEMORY_SUB_P(p))
  1582. !         relocation -= mask & x;
  1583.         else if (RELOC_MEMORY_ADD_P(p))
  1584. !         relocation += mask & x;
  1585. !       x &= ~mask;
  1586. !       x |= relocation;
  1587. ! #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1588. !       ((unsigned char *) (data + addr))[3] = x;
  1589. !       ((unsigned char *) (data + addr))[2] = x >> 8;
  1590. !       ((unsigned char *) (data + addr))[1] = x >> 16;
  1591. !       ((unsigned char *) (data + addr))[0] = x >> 24;
  1592. ! #endif
  1593. ! #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1594. !       ((unsigned char *) (data + addr))[0] = x;
  1595. !       ((unsigned char *) (data + addr))[1] = x >> 8;
  1596. !       ((unsigned char *) (data + addr))[2] = x >> 16;
  1597. !       ((unsigned char *) (data + addr))[3] = x >> 24;
  1598. ! #endif
  1599.         break;
  1600.   
  1601.       default:
  1602. ***************
  1603. *** 3790,3795 ****
  1604.       }
  1605.         p++;
  1606.       }
  1607.     mywrite (entry->textrel, 1, entry->header.a_trsize, outdesc);
  1608.   }
  1609.   
  1610. --- 4205,4214 ----
  1611.       }
  1612.         p++;
  1613.       }
  1614. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1615. +     host_to_target_reloc_byte_order((struct relocation_info *) entry->textrel,
  1616. +     entry->header.a_trsize/sizeof(struct relocation_info));
  1617. + #endif
  1618.     mywrite (entry->textrel, 1, entry->header.a_trsize, outdesc);
  1619.   }
  1620.   
  1621. ***************
  1622. *** 3849,3854 ****
  1623.       }
  1624.         p++;
  1625.       }
  1626.     mywrite (entry->datarel, 1, entry->header.a_drsize, outdesc);
  1627.   }
  1628.   
  1629. --- 4268,4277 ----
  1630.       }
  1631.         p++;
  1632.       }
  1633. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1634. +     host_to_target_reloc_byte_order((struct relocation_info *) entry->datarel,
  1635. +     entry->header.a_drsize/sizeof(struct relocation_info));
  1636. + #endif
  1637.     mywrite (entry->datarel, 1, entry->header.a_drsize, outdesc);
  1638.   }
  1639.   
  1640. ***************
  1641. *** 4056,4061 ****
  1642.     /* Output the buffer full of `struct nlist's.  */
  1643.   
  1644.     lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  1645.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  1646.     symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  1647.   
  1648. --- 4479,4496 ----
  1649.     /* Output the buffer full of `struct nlist's.  */
  1650.   
  1651.     lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  1652. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1653. +   {
  1654. +     int i;
  1655. + 
  1656. +     for (i = 0; i < bufp - buf; ++i)
  1657. +       {
  1658. +         fix_byte_order(&buf[i].n_un.n_name, sizeof(buf->n_un.n_name));
  1659. +     fix_byte_order(&buf[i].n_desc, sizeof(buf->n_desc));
  1660. +     fix_byte_order(&buf[i].n_value, sizeof(buf->n_value));
  1661. +       }
  1662. +   }
  1663. + #endif
  1664.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  1665.     symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  1666.   
  1667. ***************
  1668. *** 4068,4073 ****
  1669.     /* Now the total string table size is known, so write it.
  1670.        We are already positioned at the right place in the file.  */
  1671.   
  1672.     mywrite (&strtab_size, sizeof (int), 1, outdesc);  /* we're at right place */
  1673.   
  1674.     /* Write the strings for the global symbols.  */
  1675. --- 4503,4512 ----
  1676.     /* Now the total string table size is known, so write it.
  1677.        We are already positioned at the right place in the file.  */
  1678.   
  1679. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1680. +   fix_byte_order(&strtab_size, sizeof(strtab_size));
  1681. + #endif
  1682. + 
  1683.     mywrite (&strtab_size, sizeof (int), 1, outdesc);  /* we're at right place */
  1684.   
  1685.     /* Write the strings for the global symbols.  */
  1686. ***************
  1687. *** 5595,5600 ****
  1688.     /* All the symbols are now in BUF; write them.  */
  1689.   
  1690.     lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  1691.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  1692.     symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  1693.   
  1694. --- 6038,6055 ----
  1695.     /* All the symbols are now in BUF; write them.  */
  1696.   
  1697.     lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  1698. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1699. +   {
  1700. +     int i;
  1701. + 
  1702. +     for (i = 0; i < bufp - buf; ++i)
  1703. +       {
  1704. +     fix_byte_order(&buf[i].n_un.n_name, sizeof(buf->n_un.n_name));
  1705. +     fix_byte_order(&buf[i].n_desc, sizeof(buf->n_desc));
  1706. +     fix_byte_order(&buf[i].n_value, sizeof(buf->n_value));
  1707. +       }
  1708. +   }
  1709. + #endif
  1710.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  1711.     symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  1712.   
  1713.